﻿////////////////////////#include <iostream>
////////////////////////using namespace std;
////////////////////////class Complex
////////////////////////{
////////////////////////private:
////////////////////////	double real, image;
////////////////////////public:
////////////////////////	Complex() {};
////////////////////////	Complex(double r, double i) :real(r), image(i) {};
////////////////////////	Complex(不加&） operator+(const Complex& r_c)
////////////////////////	{
////////////////////////		Complex c3;
////////////////////////		c3.real = r_c.real + real;
////////////////////////		c3.image = r_c.image + image;
////////////////////////		return c3;
////////////////////////	}
////////////////////////	
////////////////////////	
////////////////////////	friend 	Complex operator-(const Complex& r_c1,const Complex& r_c);
////////////////////////	void print()
////////////////////////	{
////////////////////////		cout << real << " " << image << endl;
////////////////////////	}
////////////////////////};
////////////////////////Complex operator-(const Complex& r_c1, const Complex& r_c)
////////////////////////	{
////////////////////////		Complex c3;
////////////////////////		c3.real = r_c1.real-r_c.real  ;
////////////////////////		c3.image =  r_c1.image-r_c.image ;
////////////////////////		return c3;
////////////////////////	}
////////////////////////int main()
////////////////////////{
////////////////////////	int r1, i1,r2,i2;
////////////////////////	cin >> r1 >> i1>>r2>>i2;
////////////////////////	Complex complex1(r1, i1);
////////////////////////	Complex complex2(r2, i2);
////////////////////////	Complex complex3;
////////////////////////	complex3 = complex1 + complex2;
////////////////////////	complex3.print();
////////////////////////	complex3 = complex1 - complex2;
////////////////////////	complex3.print();
////////////////////////	return 0;
////////////////////////}
////////////////////////#include <iostream>
////////////////////////using namespace std;
////////////////////////class Complex
////////////////////////{
////////////////////////private:
////////////////////////	double real, image;
////////////////////////public:
////////////////////////	Complex() {};
////////////////////////	Complex(double r, double i) :real(r), image(i) {};
////////////////////////	Complex& operator+=( Complex& r_c)
////////////////////////	{
////////////////////////		real += r_c.real;
////////////////////////		image += r_c.image ;
////////////////////////		return *this;
////////////////////////	}
////////////////////////	friend 	Complex& operator-=(Complex& r_c1,  Complex& r_c);
////////////////////////	void print()
////////////////////////	{
////////////////////////		cout << real << " " << image << endl;
////////////////////////	}
////////////////////////};
////////////////////////Complex& operator-=( Complex& r_c1, Complex& r_c)
////////////////////////{
////////////////////////	r_c1.real-= r_c.real;
////////////////////////	r_c1.image -= r_c.image;
////////////////////////	return r_c1;
////////////////////////}
////////////////////////int main()
////////////////////////{
////////////////////////	int r1, i1, r2, i2;
////////////////////////	cin >> r1 >> i1 >> r2 >> i2;
////////////////////////	Complex complex1(r1, i1);
////////////////////////	Complex complex2(r2, i2);
////////////////////////	 complex1 += complex2;
////////////////////////	complex1.print();
////////////////////////	Complex complex3(r1, i1);
//////////////////////// complex3 -= complex2;
////////////////////////	complex3.print();
////////////////////////	return 0;
////////////////////////}
////////////////////////Complex(不加引用) operator + (Complex& r_c) 
////////////////////////Complex&(加引用) operator += (const Complex& r_c) 
//////////////////////#include <iostream>
//////////////////////using namespace std;
//////////////////////class Complex
//////////////////////{
//////////////////////private:
//////////////////////	double r;
//////////////////////	double i;
//////////////////////public:
//////////////////////	Complex(double real=0, double image=0) :r(real), i(image) {};
//////////////////////	friend Complex operator+(Complex& c1, Complex& c2);
//////////////////////	friend Complex operator-(Complex& c1, Complex& c2);
//////////////////////	friend Complex operator*(Complex&, Complex&);
//////////////////////	void print()
//////////////////////	{
//////////////////////		cout << "Real=" << r << " " << "Image=" << i << endl;
//////////////////////	}
//////////////////////};
//////////////////////Complex operator+(Complex& c1, Complex& c2)
//////////////////////{
//////////////////////	Complex t;
//////////////////////	t.r = c1.r + c2.r;
//////////////////////	t.i = c1.i + c2.i;
//////////////////////	return t;
//////////////////////}
//////////////////////Complex operator-(Complex& c1, Complex& c2)
//////////////////////{
//////////////////////	Complex t;
//////////////////////	t.r = c1.r -c2.r;
//////////////////////	t.i = c1.i - c2.i;
//////////////////////	return t;
//////////////////////}
//////////////////////Complex operator*(Complex& c1, Complex& c2)
//////////////////////{
//////////////////////	Complex t;
//////////////////////	t.r = c1.r*c2.r-c1.i*c2.i;
//////////////////////	t.i = c1.i * c2.r + c1.r * c2.i;
//////////////////////	return t;
//////////////////////}
//////////////////////int main()
//////////////////////{
//////////////////////	double r1,i1,r2,i2;
//////////////////////	cin >> r1>>i1>>r2>>i2;
//////////////////////	Complex complex1(r1, i1);
//////////////////////	Complex complex2(r2, i2);
//////////////////////	Complex complex3;
//////////////////////	complex3 = complex1+complex2;
//////////////////////	complex3.print();
//////////////////////	complex3 = complex1 -complex2;
//////////////////////	complex3.print();
//////////////////////	complex3 = complex1 *complex2;
//////////////////////	complex3.print();
//////////////////////	return 0;
//////////////////////
//////////////////////}
////////////////////#include <iostream>
////////////////////using namespace std;
////////////////////class Fraction
////////////////////{
////////////////////private:
////////////////////	int fz, fm;
////////////////////public:
////////////////////	Fraction(int fz_=0, int fm_=1) :fz(fz_), fm(fm_) {};
////////////////////	Fraction operator +(Fraction& c)
////////////////////	{
////////////////////		Fraction t;
////////////////////		if (fm != c.fm)
////////////////////		{
////////////////////			t.fm = fm * c.fm;
////////////////////			t.fz= fz*c.fm + c.fz*fm;
////////////////////		}
////////////////////		else
////////////////////		{
////////////////////			t.fm = fm ;
////////////////////			t.fz = fz + c.fz;
////////////////////		}
////////////////////		return t;
////////////////////	}
////////////////////	Fraction operator -(Fraction& c)
////////////////////	{
////////////////////		Fraction t;
////////////////////		if (fm != c.fm)
////////////////////		{
////////////////////			t.fm = fm * c.fm;
////////////////////			t.fz = fz*c.fm -c.fz*fm;
////////////////////		}
////////////////////		else
////////////////////		{
////////////////////			t.fm = fm;
////////////////////			t.fz = fz- c.fz;
////////////////////		}
////////////////////		return t;
////////////////////	}
////////////////////	Fraction operator *(Fraction& c)
////////////////////	{
////////////////////		Fraction t;
////////////////////		t.fm = fm * c.fm;
////////////////////		t.fz = fz * c.fz;
////////////////////		return t;
////////////////////	}
////////////////////	Fraction operator /(Fraction& c)
////////////////////	{
////////////////////		Fraction t;
////////////////////		t.fm = fm * c.fz;
////////////////////		t.fz = fz * c.fm;
////////////////////		return t;
////////////////////	}
////////////////////	void print()
////////////////////	{
////////////////////		cout << "fraction=" << fz << "/" << fm << endl;
////////////////////	}
////////////////////};
////////////////////int main()
////////////////////{
////////////////////	int fz1, fm1, fz2, fm2;
////////////////////	cin >> fz1 >> fm1 >> fz2 >> fm2;
////////////////////	Fraction fraction1(fz1, fm1);
////////////////////	Fraction fraction2(fz2, fm2);
////////////////////	Fraction fraction3;
////////////////////	fraction3 = fraction1 + fraction2;
////////////////////	fraction3.print();
////////////////////	fraction3 = fraction1 -fraction2;
////////////////////	fraction3.print();
////////////////////	fraction3 = fraction1 * fraction2;
////////////////////	fraction3.print();
////////////////////	fraction3 = fraction1 / fraction2;
////////////////////	fraction3.print();
////////////////////	return 0;
////////////////////}
//////////////////#include <iostream>
//////////////////using namespace std;
//////////////////class Vector
//////////////////{
//////////////////private:
//////////////////	int vec[5];
//////////////////public:
//////////////////	Vector() {};
//////////////////	Vector(int v[5])
//////////////////	{
//////////////////		for (int i = 0; i < 5; i++)
//////////////////		{
//////////////////			vec[i] = v[i] ;
//////////////////		}
//////////////////	}
//////////////////	Vector operator +(const Vector& obj)
//////////////////	{
//////////////////		Vector vector4;
//////////////////		for (int i = 0; i < 5; i++) 
//////////////////		{
//////////////////			vector4.vec[i] = vec[i] + obj.vec[i];
//////////////////		}
//////////////////		return vector4;
//////////////////	}
//////////////////	Vector operator -(const Vector& obj)
//////////////////	{
//////////////////		Vector vector4;
//////////////////		for (int i = 0; i < 5; i++)
//////////////////		{
//////////////////			vector4.vec[i] = vec[i] - obj.vec[i];
//////////////////		}
//////////////////		return vector4;
//////////////////	}
//////////////////	void print()
//////////////////	{
//////////////////		for (int i = 0; i < 5; i++)
//////////////////		{
//////////////////			cout << vec[i] << " ";
//////////////////		}
//////////////////		cout << endl;
//////////////////	}
//////////////////
//////////////////};
//////////////////int main()
//////////////////{
//////////////////	int vec1[5];
//////////////////	for (int i = 0; i < 5; i++)
//////////////////	{
//////////////////		cin >> vec1[i];
//////////////////	}
//////////////////	int vec2[5];
//////////////////	for (int i = 0; i < 5; i++)
//////////////////	{
//////////////////		cin >> vec2[i];
//////////////////	}
//////////////////	Vector  vector1(vec1);
//////////////////	Vector  vector2(vec2);
//////////////////	Vector  vector3;
//////////////////	//vector3.operator+(vector2);
//////////////////	vector3 = vector1 + vector2;
//////////////////	vector3.print();
//////////////////	vector3 = vector1 - vector2;
//////////////////	vector3.print();
//////////////////	return 0;
//////////////////}
//////////////////#include <iostream>
//////////////////using namespace std;
//////////////////class MyMatrix
//////////////////{
//////////////////private:
//////////////////	int** p, n;
//////////////////public:
//////////////////	MyMatrix() 
//////////////////	{
//////////////////		p = NULL;
//////////////////		n = 0;
//////////////////	}
//////////////////	MyMatrix(int n_) : n(n_) 
//////////////////	{
//////////////////		p = new int* [n];
//////////////////		for (int i = 0; i < n; i++) {
//////////////////			p[i] = new int[n]();
//////////////////		}
//////////////////	}
//////////////////	void set(int** date, int n_) 
//////////////////	{
//////////////////		n = n_;
//////////////////		p = new int* [n];
//////////////////		for (int j = 0; j < n ; j++)
//////////////////		{
//////////////////			p[j] = new int[n];
//////////////////			for (int m = 0; m < n ; m++)
//////////////////			{
//////////////////				p[j][m] = date[j][m];
//////////////////			}
//////////////////		}
//////////////////	}
//////////////////	MyMatrix(const MyMatrix& c) : n(c.n)
//////////////////	{
//////////////////			p = new int* [n];
//////////////////			for (int i = 0; i < n; i++)
//////////////////			{
//////////////////				p[i] = new int[n];
//////////////////				for (int j = 0; j < n; j++)
//////////////////				{
//////////////////					p[i][j] = c.p[i][j];
//////////////////				}
//////////////////			}
//////////////////	}
//////////////////		MyMatrix  operator *(const MyMatrix & obj)
//////////////////		{
//////////////////			MyMatrix myMatrix3(n);
//////////////////			for (int i = 0; i < n; i++)
//////////////////			{
//////////////////				for (int j = 0; j < n; j++)
//////////////////				{
//////////////////					myMatrix3.p[i][j] = 0;
//////////////////					for (int k = 0; k < n; k++)
//////////////////					{
//////////////////						myMatrix3.p[i][j] += p[i][k] * obj.p[k][j];
//////////////////					}
//////////////////				}
//////////////////			}
//////////////////			return myMatrix3;
//////////////////		}
//////////////////		MyMatrix& operator=(const MyMatrix& other)
//////////////////		{
//////////////////				n = other.n;
//////////////////				if (n > 0) {
//////////////////					p= new int* [n];
//////////////////					for (int i = 0; i < n; i++) {
//////////////////						p[i] = new int[n];
//////////////////						for (int j = 0; j < n; j++) {
//////////////////							p[i][j] = other.p[i][j];
//////////////////						}
//////////////////					}
//////////////////				}
//////////////////			return *this;
//////////////////		}
//////////////////		~MyMatrix() {
//////////////////			if (p) {
//////////////////				for (int i = 0; i < n; i++) 
//////////////////				{
//////////////////					delete[] p[i];
//////////////////				}
//////////////////				delete[] p;
//////////////////			}
//////////////////		}
//////////////////		void print()
//////////////////		{
//////////////////			for (int i = 0; i < n; i++)
//////////////////			{
//////////////////				for (int j = 0; j < n; j++)
//////////////////				{
//////////////////					cout << p[i][j];
//////////////////					if (j != n - 1)  // 不是该行最后一个元素时输出空格
//////////////////						cout << " ";
//////////////////				}
//////////////////				cout << endl;  // 每行结束后换行
//////////////////			}
//////////////////		}
//////////////////};
//////////////////int main()
//////////////////{
//////////////////	int t, n;
//////////////////	cin >> t >> n;
//////////////////	int** date = new int* [n];
//////////////////	for (int i = 0; i < n; i++)
//////////////////	{
//////////////////		date[i] = new int[n];
//////////////////	}
//////////////////	MyMatrix* myMatrix = new MyMatrix[t];
//////////////////	for (int i = 0; i < t; i++)
//////////////////	{
//////////////////		for (int j = 0; j < n ; j++)
//////////////////		{
//////////////////			for (int m = 0; m < n; m++)
//////////////////			{
//////////////////				cin >> date[j][m];
//////////////////			}
//////////////////		}
//////////////////		myMatrix[i].set(date, n);
//////////////////	}
//////////////////	MyMatrix product = myMatrix[0];
//////////////////	for (int i = 1; i < t; i++)
//////////////////	{
//////////////////		product = product * myMatrix[i];
//////////////////	}
//////////////////	product.print();
//////////////////	for (int i = 0; i < n; i++) 
//////////////////	{
//////////////////		delete[] date[i];
//////////////////	}
//////////////////	delete[] date;
//////////////////	delete[] myMatrix;
//////////////////	return 0;
//////////////////}
////////////////
////////////////#include <iostream>
////////////////#include <cmath> 
////////////////using namespace std;
////////////////class Student
////////////////{
////////////////private:
////////////////	string name;
////////////////	int y, m, d;
////////////////public:
////////////////	void set(string name_, int year, int month, int day)
////////////////	{
////////////////		name = name_;
////////////////		y= year;
////////////////		m = month;
////////////////		d = day;
////////////////	}
////////////////	string getname()
////////////////	{
////////////////		return name;
////////////////	}
////////////////	int getyear()
////////////////	{
////////////////		return y;
////////////////	}
////////////////	int getmonth()
////////////////	{
////////////////		return m;
////////////////	}
////////////////	int getday()
////////////////	{
////////////////		return d;
////////////////	}
////////////////	int days()
////////////////	{
////////////////		int days = 0;
////////////////		int month[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
////////////////		if (y % 400 == 0 || (y % 100 != 0 && y % 4 == 0))
////////////////		{
////////////////			month[2] = 29;
////////////////		}
////////////////		for (int i = 1; i < y; i++)
////////////////		{
////////////////			if (i % 400 == 0 || (i % 100 != 0 && i % 4 == 0))
////////////////			{
////////////////				days +=  366;
////////////////			}
////////////////			else
////////////////				days +=  365;
////////////////		}
////////////////		for (int i = 1; i < m; i++)
////////////////		{
////////////////			days += month[i];
////////////////		}
////////////////		days += d;
////////////////		return days;
////////////////	}
////////////////	int operator -( Student& c)
////////////////	{
////////////////		int d= c.days() - days();
////////////////		return abs(d);
////////////////	}
////////////////};
////////////////int main()
////////////////{
////////////////	string name_;
////////////////	int t,year, month, day;
////////////////	cin >> t;
////////////////	Student *p=new Student[t];
////////////////	for (int i = 0; i < t; i++)
////////////////	{
////////////////		cin>> name_>> year >> month >> day;
////////////////		p[i].set(name_, year, month, day);
////////////////	}
////////////////	int index1 = -1, index2 = -1,minx= INT_MAX;
////////////////	for (int i = 0; i < t; i++)
////////////////	{
////////////////		for (int j = i + 1; j < t; j++)
////////////////		{
////////////////			int diff = p[i] - p[j];
////////////////			if (diff < minx) 
////////////////			{
////////////////				minx = diff;
////////////////				index1 = i;
////////////////				index2 = j;
////////////////			}
////////////////		}
////////////////	}
////////////////	cout << p[index1].getname() << "和"<< p[index2].getname()<< "年龄相差最小, 为" << minx<< "天。" << endl;
////////////////	delete[]p;
////////////////	return 0;
////////////////}
//////////////#include <iostream>
//////////////using namespace std;
//////////////class Date {
//////////////public:
//////////////	Date(int y, int m, int d) { year = y; month = m; day = d; }
//////////////	friend ostream& operator<<(ostream& stream, const Date& date);
//////////////	friend istream& operator>>(istream& stream, Date& date);
//////////////private:
//////////////	int year, month, day;
//////////////};
//////////////ostream& operator <<(ostream& stream, const Date& date) { //返回引用
//////////////	stream << date.year << "/" << date.month << "/" << date.day;
//////////////	return stream;
//////////////}
//////////////istream& operator >>(istream& stream, Date& date) { //返回引用
//////////////	stream >> date.year >> date.month >> date.day;
//////////////	return stream;
//////////////}
//////////////int main() {
//////////////	Date duanwu(2021, 6, 14);
//////////////	cout << "Duanwu Festival is : " << duanwu << endl;//重载输入运算符
//////////////	cin >> duanwu;//重载输出运算符
//////////////	cout << "New date:" << duanwu << endl;//重载输入运算符
//////////////}
//////////////#include <iostream>
//////////////using namespace std;
//////////////class Date {
//////////////public:
//////////////	Date(int y, int m, int d) { year = y; month = m; day = d; }
//////////////	friend ostream& operator<<(ostream& stream, const Date& date);
//////////////	friend istream& operator>>(istream& stream, Date& date);
//////////////private:
//////////////	int year, month, day;
//////////////};
//////////////ostream& operator <<(ostream& stream, const Date& date) { //返回引用
//////////////	stream << date.year << "/" << date.month << "/" << date.day;
//////////////	return stream;
//////////////}
//////////////istream& operator >>(istream& stream, Date& date) { //返回引用
//////////////	stream >> date.year >> date.month >> date.day;
//////////////	return stream;
//////////////}
//////////////int main() {
//////////////	Date duanwu(2021, 6, 14);
//////////////	cout << "Duanwu Festival is : " << duanwu << endl;//重载输入运算符
//////////////	cin >> duanwu;//重载输出运算符
//////////////	cout << "New date:" << duanwu << endl;//重载输入运算符
//////////////}
////////////#include <iostream>
////////////using namespace std;
////////////class Complex
////////////{
////////////private:
////////////	   int real, image;
////////////public:
////////////	Complex() {};
////////////	Complex(int r, int i) :real(r), image(i) {};
////////////	Complex &operator++()
////////////	{
////////////		real++;
////////////		image++;
////////////		return *this;
////////////	}
////////////	Complex& operator++(int)
////////////	{
////////////		Complex temp = *this;
////////////		real++;
////////////		image++;
////////////		return temp;
////////////	}
////////////	friend ostream &operator<<(ostream &c,const Complex& d);
////////////	friend istream& operator>>(istream& c,  Complex& d);
////////////};
////////////ostream& operator<<(ostream& c, const Complex& d)
////////////{
////////////	cout << d.real << " " << d.image << endl;
////////////	return c;
//////////// }
////////////istream& operator>>(istream& c,  Complex& d)
////////////{
////////////	cin >> d.real>> d.image;
////////////	return c;
////////////}
////////////int main()
////////////{
////////////	int r, i;
////////////	//cin >> r >> i;
////////////	//Complex complex1(r, i);
////////////	/*Complex complex2 =++ complex1;
////////////	cout << complex2 << endl;
////////////	cout << complex1 << endl;*/
////////////	Complex complex1;
////////////	cin >> complex1;	Complex complex3 = complex1++;
////////////	cout << complex3 << endl;
////////////	cout << complex1 << endl;
////////////	return 0;
////////////}
//////#include <iostream>
//////using namespace std;
//////class Point
//////{
//////private:
//////	int x, y, z;
//////public:
//////	Point() {};
//////	Point(int x_, int y_, int z_) :x(x_), y(y_), z(z_) {};
//////	friend Point &operator++(Point& a);
//////	friend Point operator++(Point& a, int);
//////	friend Point &operator--(Point& a);
//////	friend Point operator--(Point& a, int);
//////	void show()
//////	{
//////		cout << "x=" << x << " " << "y=" << y << " " << "z=" << z << endl;
//////	}
//////};
//////Point& operator++(Point& a)
//////{
//////	a.x++; a.y++; a.z++;
//////	return a;
//////}
//////Point operator++(Point& a, int)
//////{
//////	Point temp=a;
//////	a.x++; a.y++; a.z++;
//////	return temp;
//////}
//////Point& operator--(Point& a)
//////{
//////	a.x--; a.y--; a.z--;
//////	return a;
//////}
//////Point operator--(Point& a, int)
//////{
//////	Point temp=a;
//////	a.x--; a.y--; a.z--;
//////	return temp;
//////}
//////int main()
//////{
//////	int x, y, z;
//////	cin >> x >> y >> z;
//////	Point point1(x, y, z);
//////	Point temp = point1;
//////	Point point2 = point1++;
//////	point1.show();
//////	point2.show();
//////	point1= temp;
//////	point2 = ++point1;
//////	point1.show();
//////	point2.show();
//////	point1 = temp;
//////	point2 = point1--;
//////	point1.show();
//////	point2.show();
//////	point1 = temp;
//////	point2 =-- point1;
//////	point1.show();
//////	point2.show();
//////	return 0;
//////}
//////#include <iostream>
//////using namespace std;
//////class CMoney
//////{
//////private:
//////	int yuan, jiao, fen;
//////public:
//////	CMoney() {};
//////	CMoney(int y, int j, int f) :yuan(y), jiao(j), fen(f) {};
//////	friend CMoney& operator+(CMoney& a, CMoney& b);
//////	friend CMoney& operator-(CMoney& a, CMoney& b );
//////	void show()
//////	{
//////		cout << yuan << "元" << jiao << "角" << fen << "分" << endl;
//////	}
//////};
//////CMoney cmoney1;
//////CMoney& operator+(CMoney& a, CMoney& b)
//////{
//////	cmoney1.fen = a.fen + b.fen;
//////	cout << cmoney1.fen << endl;
//////	if (cmoney1.fen >= 10)
//////	{
//////		cmoney1.jiao = cmoney1.fen / 10+ a.jiao + b.jiao;
//////		cmoney1.fen = cmoney1.fen % 10;
//////	}
//////	else
//////	{
//////		cmoney1.jiao = a.jiao + b.jiao;
//////	}
//////	if (cmoney1.jiao>= 10)
//////	{
//////		cmoney1.yuan = a.yuan + b.yuan + cmoney1.jiao / 10;
//////		cmoney1.jiao = cmoney1.jiao % 10;
//////	}
//////	else
//////	{
//////		cmoney1.yuan = a.yuan + b.yuan;
//////	}
//////	return cmoney1;
//////}
//////CMoney& operator-(CMoney& a, CMoney& b)
//////{		
//////	cmoney1.fen = a.fen - b.fen;
//////	if (a.fen < b.fen)
//////	{
//////		cmoney1.fen = a.fen + 10 - b.fen;
//////		a.jiao = a.jiao - 1;
//////	}
//////	else
//////	{
//////		cmoney1.fen = a.fen - b.fen;
//////	}
//////
//////	 if (a.jiao < b.jiao)
//////	{
//////		cmoney1.jiao = a.jiao+ 10 - b.jiao;
//////		a.yuan = a.yuan - 1;
//////	}
//////	 else
//////	 {
//////		 cmoney1.jiao = a.jiao - b.jiao;
//////	 }
//////	cmoney1.yuan = a.yuan - b.yuan;
//////	return cmoney1;
//////}
//////int main()
//////{
//////	int t,y0,j0,f0,y,j,f;
//////	string type;
//////	cin >> t;
//////	for (int i = 0; i < t; i++)
//////	{
//////		cin >> y0 >> j0 >> f0;
//////		CMoney cmoney1(y0, j0, f0);
//////		while (1)
//////		{
//////			cin >> type;
//////			if (type == "stop")
//////			{
//////				break;
//////			}
//////			else
//////			{
//////				cin >> y >> j >> f;
//////				if (type == "add")
//////				{
//////					CMoney cmoney2(y, j, f);
//////					cmoney1 = cmoney1 + cmoney2;
//////					cmoney1.show();
//////				}
//////				else if(type=="minus")
//////				{
//////					CMoney cmoney2(y, j, f);
//////					cmoney1 = cmoney1 - cmoney2;
//////					cmoney1.show();
//////				}
//////			}
//////		}
//////		cmoney1.show();
//////	}
//////	return 0;
//////}
////#include <iostream>
////using namespace std;
////class Clock
////{
////private:
////	int hour, minute, second;
////public:
////	Clock() {};
////	Clock(int h, int m, int s) :hour(h), minute(m), second(s) {};
////	Clock& operator++()
////	{
////		second++;
////		if (second >= 60)
////		{
////			minute = minute + second / 60;
////			second = second % 60;
////		}
////		if (minute >= 60)
////		{
////			hour = hour + minute / 60;
////			minute = minute %60;
////		}
////		hour = hour % 12;
////		return *this;
////	}
////	Clock operator--(int)
////	{
////		Clock temp=*this;
////		second--;
////		if (second < 0)
////		{
////			minute = minute -1;
////			second = second +60 ;
////		}
////		if (minute < 0) 
////		{
////			hour = hour -1;
////			minute = minute +60;
////		}
////		if (hour < 0)
////		{
////			hour = hour+12;
////		}
////		else
////		{
////			hour = hour % 12;
////		}
////		return temp;
////	}
////	void show()
////	{
////		cout << hour << ":" << minute << ":" << second << endl;
////	}
////};
////int main()
////{
////	int h, m, s,t,x;
////	cin >>h>>m>>s>> t;
////	Clock clock1(h, m, s);
////	Clock clock2;
////	for (int i = 0; i < t; i++)
////	{
////		cin >> x;
////		if (x > 0)
////		{
////			for (int i = 0; i < x; i++)
////			{
////				clock2 = ++clock1;
////				
////			}clock2.show();
////		}
////		else if (x<0)
////		{
////			x = -x;
////			for (int i = 0; i < x; i++)
////			{
////				clock2 = clock1--;
////			}
////			clock1.show();
////		}
////		else
////		{
////			clock1.show();
////		}
////	}
////	return 0;
////}
#include <iostream>
using namespace std;
class CPoint
{
private:
    int x, y;
public:
    CPoint(int x_,int y_) :x(x_), y(y_) {};
    int getx()
    {
        return x;
    }
    int gety()
    {
        return y;
    }
};
class CRectangle
{
private:
    CPoint leftPoint, rightPoint;
public:
    CRectangle(CPoint &leftPoint_, CPoint & rightPoint_) :leftPoint(leftPoint_), rightPoint(rightPoint_){};
    operator int()
    {
        int s = ((rightPoint.getx() - leftPoint.getx()) * (leftPoint.gety() - rightPoint.gety()));
        return int(s);
    }
    bool operator>(CPoint& p)
    {
        if ((p.getx() >=leftPoint.getx() && p.getx() <= rightPoint.getx() && p.gety() >= rightPoint.gety() && p.gety() <=leftPoint.gety()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator>(CRectangle &c)
    {
        if (*this>c.leftPoint&&*this>c.rightPoint)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator*(CRectangle& c)
    {
        if (max(leftPoint.getx(),c.leftPoint.getx())<=min(rightPoint.getx(),c.rightPoint.getx())&&(min(leftPoint.gety(),c.leftPoint.gety())>=max(rightPoint.gety(),c.rightPoint.gety())))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator==(CRectangle& c)
    {
        if ((leftPoint.getx()==c.leftPoint.getx())&&(leftPoint.gety() == c.leftPoint.gety()) && (rightPoint.getx() == c.rightPoint.getx())&&(rightPoint.gety() ==c.rightPoint.gety()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    friend ostream& operator<<(ostream& c,  CRectangle& d);
};
ostream& operator<<(ostream& c,CRectangle& d)
{
    c << d.leftPoint.getx() << " " << d.leftPoint.gety() << " " << d.rightPoint.getx() << " " << d.rightPoint.gety();
    return c;
}
int main()
{
    int t, x1, x2, y1, y2, x3, x4, y3, y4;
    cin >> t;
    while (t--)
    {
        cin >> x1 >> y1 >> x2 >> y2;
        if (x1 < 0)
            x1 = -x1;
        if (y1 < 0)
            y1 = -y1;
        if (x2 < 0)
            x2 = -x2;
        if (x2 < 0)
            x2 = -x2;
        CPoint cpoint1(x1,y1);
        CPoint cpoint2(x2, y2);
        CRectangle rect1(cpoint1, cpoint2);
        cin >> x3 >> y3 >> x4 >> y4;
        if (x3 < 0)
            x3= -x3;
        if (y3 < 0)
            y3 = -y3;
        if (x4 < 0)
            x4 = -x4;
        if (y4 < 0)
            y4 = -y4;
        CPoint cpoint3(x3, y3);
        CPoint cpoint4(x4, y4);
        CRectangle rect2(cpoint3, cpoint4);
        cout << "矩形1:" << rect1 << " " << (int)rect1 << endl;
        cout << "矩形2:" << rect2 << " " << (int)rect2 << endl;
        if (rect1 == rect2)
        {
            cout << "矩形1和矩形2相等" << endl;
        }
        else if (rect2 > rect1)
        {
            cout << "矩形2包含矩形1" << endl;
        }
        else if (rect1 > rect2)
        {
            cout << "矩形1包含矩形2" << endl;
        }
        else if (rect1 * rect2)
        {
            cout << "矩形1和矩形2相交" << endl;
        }
        else
        {
            cout << "矩形1和矩形2不相交" << endl;
        }
        cout << endl;
    }
    return 0;
}
//#include <iostream>
//using namespace std;
//class CXGraph
//{
//private:
//    int n_;
//public:
//    CXGraph() {};
//    CXGraph(int n) :n_(n) {};
//    CXGraph operator++(int)
//    {
//        CXGraph temp = *this;
//            n_ = n_ + 2;
//            if (n_ > 21)
//            {
//                n_ = 21;
//            }
//        return temp;
//    }
//    CXGraph &operator++()
//    {
//        n_ = n_ + 2;
//        if (n_ > 21)
//        {
//            n_ =21;
//        }
//        return *this;
//    }
//    CXGraph operator--(int)
//    {
//        CXGraph temp = *this;
//        n_ = n_ - 2;
//        if (n_ < 1)
//        {
//            n_ = 1;
//        }
//        return temp;
//    }
//    CXGraph &operator--()
//    {
//        n_ = n_ - 2;
//        if (n_ < 1)
//        {
//           n_ = 1;
//        }
//        return *this;
//    }
//    friend ostream& operator<<(ostream& c,const CXGraph& d);
//};
//ostream& operator<<(ostream& c,const CXGraph& d)
//{
//  
//    if (d.n_ == 1) 
//    {
//        c << "X" << endl;
//    }
//    else
//    {
//        int a = 0;
//        for (int j = d.n_; j > 0; j -= 2)
//        {
//            for (int k = 1; k <= a; k++)
//            {
//                c << " ";
//            }
//            for (int i = 1; i <= j; i++)
//            {
//                c << "X";
//            }
//            c << endl;
//            a++;
//        }
//        a = d.n_ / 2 - 1;
//        for (int j = 3; j <= d.n_; j += 2)
//        {
//            for (int k = 1; k <= a; k++)
//            {
//                c << " ";
//            }
//            for (int i = 1; i <= j; i++)
//            {
//                c << "X";
//            }
//            c << endl;
//            a--;
//        }
//    }
//    return c;
//}
//int main()
//{
//    int t, n;
//    string command;
//    cin >> n;
//    CXGraph xGraph(n);
//    cin >> t;
//    while (t--)
//    {
//        cin >> command;
//        if (command == "show++")
//        {
//            cout << xGraph++ << endl ;
//        }
//        else if (command == "++show")
//        {
//            cout << ++xGraph << endl ;
//        }
//        else if (command == "--show")
//        {
//            cout << --xGraph << endl ;
//        }
//        else if (command == "show--")
//        {
//            cout << xGraph-- << endl ;
//        }
//        else if (command == "show")
//        {
//            cout << xGraph << endl ;
//        }
//    }
//    return 0;
//}